home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / HDLFILE / OPTIMIZE.S < prev    next >
Encoding:
Text File  |  2001-02-09  |  28.7 KB  |  1,490 lines
  1. *************************************************************************
  2. *            Revision Control System
  3. * =======================================================================
  4. *  $Revision: 2.2 $    $Source: /u2/MRS/osrevisions/aes/optimize.s,v $
  5. * =======================================================================
  6. *  $Author: mui $    $Date: 89/04/26 18:29:34 $    $Locker:  $
  7. * =======================================================================
  8. *  $Log:    optimize.s,v $
  9. * Revision 2.2  89/04/26  18:29:34  mui
  10. * TT
  11. * 
  12. * Revision 2.1  89/02/22  05:31:30  kbad
  13. * *** TOS 1.4  FINAL RELEASE VERSION ***
  14. * 
  15. * Revision 1.1  88/06/02  12:36:01  lozben
  16. * Initial revision
  17. * 
  18. *************************************************************************
  19. * --
  20. *
  21. * optimize.s
  22. * 02/02/87    Totally rewritten from optimize.c    Mike Schmal
  23. *
  24. *        Grect - a block of four contiguous words representing a 
  25. *            graphics rectangle x,y,w,h
  26. *
  27. * NOTE    One day we should remove calls to inf_sget and use fs_sget since
  28. *    they are the same function.
  29. *
  30. * UPDATES:
  31. *    02/24/87 Bug in fmt_str now checks for null when skipping extension
  32. *         '.'.
  33. * Fix bug at unfmt_str    2/23/88        D.Mui
  34. * --
  35.  
  36. *
  37. OB_FLAGS    =    $8
  38. OB_STATE    =    $a
  39. OB_SPEC        =    $c
  40. OB_SIZE        =    $18
  41. *
  42. TEDTXTLEN    =    $18
  43. *
  44. PERCENT        =    $25
  45. CAP_L        =    $4c
  46. CAP_W        =    $57
  47. CAP_S        =    $53
  48. DOT        =    $2e
  49. SPACE        =    $20
  50. QUEST        =    $3f
  51. STAR        =    $2a
  52.  
  53. * --
  54. * external variables
  55. * --
  56.     .globl _gl_wchar
  57.     .globl _gl_hchar
  58.     .globl _r_get
  59.  
  60. * --
  61. * internal defined routines
  62. * --
  63.     .globl    _r_get
  64.     .globl    _r_set
  65.     .globl _rc_copy
  66.     .globl _rc_equal
  67.     .globl _rc_inter
  68.     .globl _rc_union
  69.     .globl _rc_const
  70.     .globl _movs
  71.     .globl _min
  72.     .globl _max
  73.     .globl _inside
  74.     .globl _strlen
  75.     .globl _strcmp
  76.     .globl _strcpy
  77.     .globl _strscn
  78.     .globl _strchk
  79.     .globl _toupper
  80.     .globl _fmt_str
  81.     .globl _unfmt_st
  82.     .globl _fs_sset
  83.     .globl _inf_sset
  84.     .globl _fs_sget
  85.     .globl _inf_sget
  86.     .globl _inf_fldset
  87.     .globl _inf_gind
  88.     .globl _inf_what
  89.     .globl _merge_st
  90.     .globl _strcat
  91.     .globl _bfill
  92.     .globl _wildcmp
  93.     .globl _scasb
  94.  
  95.     .text
  96. * --
  97. *
  98. * r_get        Routine to set the variables x,y,w,h to the values found
  99. *        in an x,y,w,h block (grect)
  100. *        C binding:    r_get(xywhptr,xptr,yprt,wptr,hptr);
  101. *                int    *xywhptr;
  102. *                int    *xptr,*yptr,*wptr,*hptr;
  103. * --
  104. _r_get:
  105.     movem.l    a3-a4,-(sp)    ; save a3,a4
  106.     movem.l    12(sp),a0-a4    ; a0 -> grect , a1->x, a2->y, a3->w, a4->h
  107.     move.w    (a0)+,(a1)    ; set x from grect
  108.     move.w     (a0)+,(a2)    ; set y
  109.     move.w    (a0)+,(a3)    ; set w
  110.     move.w    (a0)+,(a4)    ; set h
  111.     movem.l    (sp)+,a3-a4    ; restore
  112.     rts
  113.  
  114. * --
  115. *
  116. * _r_set    Routine to set a x,y,w,h block to the x,y,w,h values passed
  117. *        in.
  118. *        C binding:    r_set(xywhptr,x,y,w,h);
  119. *                int    *xywhptr;
  120. *                int    x,y,w,h;
  121. * --
  122. _r_set:
  123.     movem.l    4(sp),a0-a2    ; a0 -> grect, a1 = x and y, a2 = w and h
  124.     movem.l    a1-a2,(a0)    ; set x and y and w and h
  125.     rts
  126.  
  127.  
  128. * --
  129. *
  130. * rc_copy    Copy src xywh block to dest xywh block.
  131. *        C binding:    r_copy(srcxywh,dstxywh);
  132. *                GRECt    *srcxywh,*dstxywh;
  133. *
  134. * --
  135. _rc_copy:
  136.     movem.l    4(sp),a0-a1    ; a0 ->src, a1 ->dest
  137.     move.l    (a0)+,(a1)+    ; set x and y
  138.     move.l    (a0)+,(a1)+    ; set w and h
  139.     rts
  140.  
  141.  
  142. * --
  143. *
  144. * inside    Return true if the x,y position is within the grect
  145. *        C binding:    inside(x,y,ptr1);
  146. *                int    x,y;
  147. *                GRECT    *ptr1;
  148. * --
  149. _inside:
  150.     movem.w    4(sp),d0-d1    ; d0 = x, d1 = y
  151.     move.l    8(sp),a0    ; a0 -> grect
  152.     cmp.w    (a0),d0        ; if (x1 >= x)
  153.     blt    retfalse
  154.     cmp.w    2(a0),d1    ; && (y1 >= y)
  155.     blt    retfalse
  156.     move.w    (a0),d2        ; d2 = x1
  157.     add.w    4(a0),d2    ; d2 = x1 +w1
  158.     cmp.w    d2,d0        ; && ( x1+w1 <= x )
  159.     bge    retfalse
  160.     move.w    2(a0),d2    ; d2 = y1
  161.     add.w    6(a0),d2    ; d2 y2+h2
  162.     cmp.w    d2,d1        ; && ( y1+h1 <= y)
  163.     bge    retfalse
  164.     bra    rettrue
  165.  
  166.  
  167. * --
  168. *
  169. * rc_equal    Returns true if the two grects are equal.
  170. *        C binding:    rc_equal(ptr1,ptr2);
  171. *                int    *ptr1,ptr2*
  172. * --
  173. _rc_equal:
  174.     movem.l    4(sp),a0-a1    ; a0 -> grect 1, a1 -> grect 2
  175.     cmpm.l    (a0)+,(a1)+    ; are the x and y equal
  176.     bne    retfalse
  177.     cmpm.l    (a0)+,(a1)+    ; are the w and h equal
  178.     bne    retfalse
  179.     bra    rettrue
  180.  
  181. * --
  182. *
  183. * rc_intersect    Returns the intersection of two rectangles in ptr2.
  184. *        Returns true if there was an intersection where the width
  185. *        is greater than x and the height is greater than y.
  186. *        C binding:    rc_intersect(ptr1,ptr2);
  187. *                GRECT    *ptr1,*ptr2;
  188. *
  189. * --
  190. _rc_inter:
  191.     movem.l    4(sp),a0-a1    ; a0 = grect 1, a1 = grect 2
  192.     move.w    (a1),d0        ; d0 = x2
  193.     cmp.w    (a0),d0        ; If (x1 < x2)
  194.     bge    int1
  195.     move.w    (a0),d0        ; d0 = max(x1,x2)
  196. int1:
  197.     move.w    (a0),d1        ; d1 = x1
  198.     add.w    4(a0),d1    ; d1 = x1 + w1
  199.     move.w    (a1),d2        ; d2 = x2
  200.     add.w    4(a1),d2    ; d2 = x2 + w2
  201.     cmp.w    d1,d2        ; IF (x1+w1 > x2+w2)
  202.     ble    int2
  203.     move.w    d1,d2        ; d2 = min(x1+w1,x2+w2)
  204. int2:
  205.     move.w    d0,(a1)        ; x2 = max(x1,x2)
  206.     sub.w    d0,d2
  207.     move.w    sr,-(sp)    ; save status
  208.     move.w    d2,4(a1)    ; w2 = min(x1+w1,x2+w2) - max(x1,x2)
  209. *
  210.     move.w    2(a1),d0    ; d0 = y2
  211.     cmp.w    2(a0),d0    ; If (y1 < y2)
  212.     bge    int3
  213.     move.w    2(a0),d0    ; d0 = max(y1,y2)
  214. int3:
  215.     move.w    2(a0),d1    ; d1 = y1
  216.     add.w    6(a0),d1    ; d1 = y1 + h1
  217.     move.w    2(a1),d2    ; d2 = y2
  218.     add.w    6(a1),d2    ; d2 = y2 + h2
  219.     cmp.w    d1,d2        ; IF (y1+h1 > y2+h2)
  220.     ble    int4
  221.     move.w    d1,d2        ; d2 = min(y1+h1,y2+h2)
  222. int4:
  223.     move.w    d0,2(a1)    ; y2 = max(y1,y2)
  224.     sub.w    d0,d2
  225.     move.w    sr,d0        ; save status in d0 (ty > th)
  226.     move.w    d2,6(a1)    ; h2 = min(y1+h1,y2+h2) - max(y1,y2)
  227.     move.w    (sp)+,ccr    ; if (tw > tx)
  228.     ble    retfalse
  229.     move.w    d0,ccr        ; && (ty > th)
  230.     ble    retfalse
  231.     bra    rettrue
  232.  
  233. * --
  234. *
  235. * rc_union    Returns the union of two rectangles in ptr2.
  236. *        C binding:    rc_union(ptr1,ptr2);
  237. *                GRECT    *ptr1,*ptr2;
  238. *
  239. * --
  240. _rc_union:
  241.     movem.l    4(sp),a0-a1    ; a0 = ptr block 1, a1 = ptr block 2
  242.     move.w    (a1),d0        ; d0 = x2
  243.     cmp.w    (a0),d0        ; If (x1 < x2)
  244.     blt    uni1
  245.     move.w    (a0),d0        ; d0 = min(x1,x2)
  246. uni1:
  247.     move.w    (a0),d1        ; d1 = x1
  248.     add.w    4(a0),d1    ; d1 = x1 + w1
  249.     move.w    (a1),d2        ; d2 = x2
  250.     add.w    4(a1),d2    ; d2 = x2 + w2
  251.     cmp.w    d1,d2        ; IF (x1+w1 > x2+w2)
  252.     bgt    uni2
  253.     move.w    d1,d2        ; d2 = min(x1+w1,x2+w2)
  254. uni2:
  255.     sub.w    d0,d2
  256.     move.w    d0,(a1)        ; x2 = min(x1,x2)
  257.     move.w    d2,4(a1)    ; w2 = max(x1+w1,x2+w2) - min(x1,x2)
  258. *
  259.     move.w    2(a1),d0    ; d0 = y2
  260.     cmp.w    2(a0),d0    ; If (y1 < y2)
  261.     blt    uni3
  262.     move.w    2(a0),d0    ; d0 = min(y1,y2)
  263. uni3:
  264.     move.w    2(a0),d1    ; d1 = y1
  265.     add.w    6(a0),d1    ; d1 = y1 + h1
  266.     move.w    2(a1),d2    ; d2 = y2
  267.     add.w    6(a1),d2    ; d2 = y2 + h2
  268.     cmp.w    d1,d2        ; IF (y1+h1 > y2+h2)
  269.     bgt    uni4
  270.     move.w    d1,d2        ; d2 = max(y1+h1,y2+h2)
  271. uni4:
  272.     sub.w    d0,d2
  273.     move.w    d0,2(a1)    ; y2 = min(y1,y2)
  274.     move.w    d2,6(a1)    ; h2 = max(y1+h1,y2+h2) - min(y1,y2)
  275.     rts
  276.  
  277.  
  278. * --
  279. *
  280. * rc_constrain    Routine to constrain a box within another box.  This is done by
  281. *        seting the x,y of the inner box to remain within the
  282. *        constraining box.
  283. *        C binding:    r_constrain(const_ptr,xywhptr);
  284. *                GRECT    *const_ptr,*xywhptr;
  285. * --
  286. _rc_const:
  287.     movem.l    4(sp),a0-a1    ; a0 -> x of constrain rect, a1 -> grect
  288.     move.w    (a0),d0        ; d0 = const_x
  289.     cmp.w    (a1),d0        ; If ( x < const_x )
  290.     blt    clp_right
  291.     move.w    d0,(a1)        ; yes set x
  292. clp_right:
  293.     add.w    4(a0),d0    ; d0 = const_x+const_w
  294.     move.w    (a1),d1        ; d1 = x
  295.     add.w    4(a1),d1    ; d1 = x+w
  296.     cmp.w    d1,d0        ; If ( x+w < const_x+const_w )
  297.     bge    do_y
  298.     sub.w    4(a1),d0    ; d0 =     const_x+const_w-w
  299.     move.w    d0,(a1)        ; set x
  300. do_y:
  301.     move.w    2(a0),d0    ; d0 = const_y
  302.     cmp.w    2(a1),d0    ; If ( y < const_y )
  303.     blt    clp_bottom
  304.     move.w    d0,2(a1)    ; yes set y
  305. clp_bottom:
  306.     add.w    6(a0),d0    ; d0 = const_y+const_h
  307.     move.w    2(a1),d1    ; d1 = y
  308.     add.w    6(a1),d1    ; d1 = y+h
  309.     cmp.w    d1,d0        ; If ( y+h < const_y+const_h )
  310.     bge    rc_done
  311.     sub.w    6(a1),d0    ; d0 =     const_y+const_h-h
  312.     move.w    d0,2(a1)    ; set y
  313. rc_done:
  314.     rts
  315.  
  316. * --
  317. *
  318. * movs    move bytes from source to dest for a count of N
  319. *        C binding:    movs(count,src,dst);
  320. *                int    count;
  321. *                byte    *src,*dst;
  322. * --
  323. _movs:
  324.     move.w    4(sp),d0    ; count
  325.     movem.l    6(sp),a0-a1    ; a0 -> source, a1 -> dest
  326.     bra    stmovs
  327. movnxt:
  328.     move.b (a0)+,(a1)+
  329. stmovs:
  330.     dbra    d0,movnxt
  331.     rts
  332.  
  333. * --
  334. *
  335. * min    Returns minimum value of two words
  336. *        C binding:    min(a,b);
  337. *                int    a,b;
  338. * --
  339. _min:
  340.     move.w    4(sp),d0    ; d0 = a
  341.     cmp.w    6(sp),d0    ; if (a < b)
  342.     blt    genret
  343.     bra    minmax
  344.  
  345. * --
  346. *
  347. * max    Returns maximum value of two words
  348. *        C binding:    max(a,b);
  349. *                int    a,b;
  350. * --
  351. _max:
  352.     move.w    4(sp),d0    ; d0 = a
  353.     cmp.w    6(sp),d0    ; if (a > b)
  354.     bgt    genret
  355. minmax:
  356.     move.w    6(sp),d0
  357. genret:
  358.     rts            ; general rts
  359.  
  360. * --
  361. *
  362. * bfill        Copy the byte passed in to the dest pointer for a count of N
  363. *        C binding:    bfill(count,byte,dest);
  364. *                int    count;
  365. *                byte    byte;
  366. *                byte    *dest;
  367. * --
  368. _bfill:
  369.     move.w    4(sp),d0    ; d0 = count
  370.     move.b    7(sp),d1    ; d1 = byte
  371.     move.l    8(sp),a0    ; a0 = dest
  372.     bra    bfout
  373. bfnxt:
  374.     move.b    d1,(a0)+
  375. bfout:
  376.     dbra    d0,bfnxt
  377.     rts
  378.  
  379. * --
  380. *
  381. * toupper    Return upper case value
  382. *        C binding:    toupper(chr);
  383. *                byte    chr;
  384. * --
  385. _toupper:
  386.     move.b    5(sp),d0    ; d0 = chr
  387.     ext.w    d0        ; extend to word
  388.     cmp.w    #97,d0        ; if (chr >= 'a')
  389.     blt    toupout
  390.     cmp.w    #122,d0        ; if (chr <= 'z')
  391.     bgt    toupout
  392.     add.w     #-32,d0    ; upper it
  393. toupout:
  394.     rts
  395.  
  396.  
  397. * --
  398. *
  399. * strlen    Need I say more
  400. *        C binding:    word    strlen(ptr);
  401. *                    byte    *ptr;
  402. * --
  403. _strlen:
  404.     move.l    4(sp),a0    ; a0 -> string
  405.     clr.w    d0
  406. strnxt:
  407.     tst.b    (a0)+        ; if (end of string)
  408.     beq    genrts
  409.     addq.w    #1,d0        ; inc count
  410.     bra    strnxt
  411.  
  412. * --
  413. *
  414. * strcmp    dito
  415. *        C binding:    word    strcmp(ptr1,ptr2);
  416. *                    byte    *ptr1,*ptr2;
  417. * --
  418. _strcmp:
  419.     movem.l 4(sp),a0-a1    ; a0 ->string1, a1 ->string2
  420. cmpnxt:
  421.     tst.b    (a0)        ; if (we have char)
  422.     beq    cmp1
  423.     cmpm.b (a0)+,(a1)+    ; if (they match)
  424.     beq    cmpnxt
  425.     bra    retfalse
  426. cmp1:
  427.     tst.b    (a1)        ; if (no char)
  428.     bne    retfalse
  429.     bra    rettrue        ; else ret true
  430.  
  431. * --
  432. *
  433. * strcpy    dito dito
  434. *        C binding:    byte    *strcpy(src,dst);
  435. *                    byte    *src,*dst;
  436. * --
  437. _strcpy:
  438.     movem.l    4(sp),a0-a1    ; a0 -> src, a1 -> dst
  439. cpynxt:
  440.     move.b    (a0)+,(a1)+    ; dst = src
  441.     bne    cpynxt
  442.     bra    catscn
  443.  
  444. * --
  445. *
  446. * strscn    copy the src to destination untill we are out of characters
  447. *        or we get a char match.
  448. *        C binding:    byte    *strscn(src,dst,stopchar);
  449. *                    byte    *src,*dst,stopchar;
  450. *
  451. * --
  452. _strscn:
  453.     movem.l    4(sp),a0-a1    ; a0 -> src, a1 -> dst
  454.     move.b    13(sp),d0    ; d0 = char
  455. scnxt:
  456.     cmp.b    (a0),d0        ; if( (src) != char)
  457.     beq    catscn
  458.     tst.b    (a0)        ; && (we have source)
  459.     beq    catscn
  460.     move.b    (a0)+,(a1)+
  461.     bra    scnxt
  462.  
  463. * --
  464. *
  465. * strcat    dito dito dito
  466. *        C binding:    byte    *strcat(src,dst);
  467. * --
  468. _strcat:
  469.     movem.l    4(sp),a0-a1    ; a0 -> src, a1 -> dst
  470. catend:
  471.     tst.b    (a1)+        ; if (not at end of dst string)
  472.     bne    catend
  473.     sub.l    #1,a1        ; now at end of str
  474. ;
  475. catnxt:
  476.     move.b    (a0)+,(a1)+    ; dst = scr
  477.     bne    catnxt
  478. catscn:
  479.     move.l    a1,d0        ; return dest pointer
  480.     rts
  481.  
  482. * --
  483. *
  484. * scasb        Returns a byte pointer pointing to the matched byte or
  485. *        the end of the string.
  486. *        C binding:    byte    *scasb(ptr,byte);
  487. *                    byte    *ptr,byte;
  488. *
  489. * --
  490. _scasb:
  491.     move.l    4(sp),a1    ; a1 -> string
  492.     move.b    9(sp),d0    ; d0 = byte
  493. scanxt:
  494.     tst.b    (a1)        ; if (end of string)
  495.     beq    catscn
  496.     cmp.b    (a1),d0        ; if ((ptr) == byte)
  497.     beq    catscn
  498.     add.l    #1,a1        ; next char
  499.     bra    scanxt
  500.  
  501.  
  502. * --
  503. *
  504. * strchk    This is the true version of strcmp. Shall we remove the
  505. *        other -we shall see!!!
  506. *        Returns    - <0 if(str1<str2), 0 if(str1=str2), >0 if(str1>str2)
  507. *        C binding:    word    strchk(str1,str2);
  508. *                    byte    *str1,*str2;
  509. *
  510. * --
  511. _strchk:
  512.     movem.l    4(sp),a0-a1    ; a0 -> string 1, a1 -> string 2
  513.     clr.w    d0        ; init to strings equal
  514. chknxt:
  515.     move.b    (a0),d1        ; get str1 char
  516.     cmp.b    (a1)+,d1    ; if ( strings are not equal )
  517.     bne    chk1
  518.     tst.b    (a0)+        ; if ( end of string )
  519.     beq    chkout
  520.     bra    chknxt
  521. chk1:
  522.     move.b    (a0),d0
  523.     ext.w    d0
  524.     move.b    -1(a1),d1    ; a1 is ahead by 1 at this point
  525.     ext.w    d1
  526.     sub.w    d1,d0        ; return (byte1 - byte2)
  527. chkout:
  528.     rts
  529.  
  530. ; --
  531. ;
  532. ; fmt_str    Routine to strip out '.' from string and return raw
  533. ;        data. Pad with spaces ex. "this.p" to "this    p"
  534. ;        C binding:    fmt_str(src,dst);
  535. ;                    byte    ;src,*dst;
  536. ; --
  537. _fmt_str:
  538.     movem.l    4(sp),a0-a1    ; a0 -> src, a1 -> dst
  539.     move.w    #7,d0        ; init for filename
  540. fmtnxt:
  541.     tst.b    (a0)
  542.     beq    padit
  543.     cmp.b    #DOT,(a0)    ; char = '.'    
  544.     beq    padit
  545.     move.b (a0)+,(a1)+    ; copy char
  546.     dbra    d0,fmtnxt
  547.     bra    extens
  548. padit:
  549.     tst.b    (a0)
  550.     beq    unfout
  551. fmt1:
  552.     move.b #' ',(a1)+    ; pad with ' '
  553.     dbra    d0,fmt1
  554. extens:
  555.     tst.b    (a0)+        ; inc past '.'
  556.     beq    unfout        ; if(null) exit
  557. fmt2:
  558.     tst.b    (a0)
  559.     beq    unfout
  560.     move.b (a0)+,(a1)+    ; copy char
  561.     bra    fmt2
  562.  
  563. * --
  564. *
  565. * unfmt_str    Routine to convert a string of type "mike    xxx" to
  566. *        a dos string of "mike.xxx"
  567. *        C binding:    unfmt_str(src,dst);
  568. *                byte    *src,*dst;
  569. * --
  570. _unfmt_st:
  571.     movem.l    4(sp),a0-a1    ; a0 -> src, a1 -> dst
  572.     move.w    #7,d0        ; init for filename
  573. unfnxt:
  574.     move.b    (a0)+,d1    ; get char
  575.     tst.b    d1    
  576.     beq    unfout        ; no more character
  577.     cmp.b    #SPACE,d1    ; if (space)
  578.     beq    unfskip
  579.     move.b    d1,(a1)+    ; copy char
  580. unfskip:
  581.     dbra    d0,unfnxt
  582.     tst.b    (a0)        ; fix the dot
  583.     beq    unfout
  584.     move.b    #DOT,(a1)+    ; add '.'
  585. unfext:
  586.     tst.b    (a0)        ; If (extension)
  587.     beq    unfout
  588.     move.b    (a0)+,(a1)+
  589.     bra    unfext
  590. unfout:
  591.     clr.b    (a1)        ; null terminate dest
  592.     rts
  593.  
  594.  
  595. * --
  596. *
  597. * fs_sset    Copy the long in the ob_spec field to the callers variable
  598. *        ptext.  Next copy the string located at the ob_spec long to the
  599. *        callers pstr.  Finally copy the length of the tedinfo string
  600. *        to the callers ptxtlen.
  601. *        C binding:    fs_sset(tree,obj,pstr,ptext,ptxtlen);
  602. *                    long    tree,pstr,*ptext;
  603. *                    word    obj,*ptxtlen;
  604. * --
  605. _fs_sset:
  606.     move.l    14(sp),a1    ; a1 -> ptext
  607. ;
  608.     move.l    #OB_SPEC,a0    ; a0 = ob_spec offset
  609.     bsr    get_addr
  610.     move.l    (a0),a0        ; a0 -> tedinfo block
  611. ;
  612.     move.l    (a0),(a1)    ; set callers ptext to tedinfo data string
  613.     move.l    a0,-(sp)    ; save pointer to tedinfo block
  614. ;
  615.     move.l 14(sp),-(sp)    ; sp = pstr
  616.     move.l (a0),-(sp)    ; sp = tedinfo text data
  617.     addq.l #8,sp
  618.     move.l    (sp)+,a0    ; get pointer to tedinfo structure
  619. ;
  620.     move.l    18(sp),a1    ; ptxtlen
  621.     add.l    #TEDTXTLEN,a0    ; now points to tedinfo text length
  622.     move.w    (a0),(a1)    ; store it
  623.     rts
  624.  
  625. * --
  626. *
  627. * inf_sset
  628. *        C binding:    inf_sset(tree,obj,pstr,&text,&txtlen);
  629. *
  630. * --
  631. _inf_sset:
  632.     link    a6,#-8        ; room for temp variables
  633.     pea    $FFFA(a6)    ; addr of txtlen    (-6)
  634.     pea    $FFFC(a6)    ; addr of text        (-4)
  635.     move.l    14(a6),-(sp)    ; pstr
  636.     move.w    12(a6),-(sp)    ; obj
  637.     move.l    8(a6),-(sp)    ; tree
  638.     jsr    _fs_sset
  639.     adda.l    #18,sp
  640.     unlk    a6
  641.     rts
  642.  
  643. * --
  644. * inf_sget
  645. * fs_sget    This routine copies the tedinfo string to the dst pointer.
  646. *        The function inf_sget was the same as fs_sget.
  647. *        C binding:    inf_sget(tree,obj,dst);
  648. *        C binding:    fs_sget(tree,obj,dst);
  649. *                long    tree,dst;
  650. *                word    obj;
  651. * --
  652. _inf_sget:
  653. _fs_sget:
  654.     move.l    #OB_SPEC,a0    ; a0 = offset to ob_spec
  655.     bsr    get_addr
  656.     move.l    (a0),a0        ; a0 = ob_spec pointer
  657. ;
  658.     move.l    (a0),-(sp)    ; sp = addr of tedinfo str
  659.     move.l    14(sp),-(sp)    ; sp = destination
  660.     addq.l    #8,sp
  661.     rts
  662.  
  663.  
  664.  
  665. * --
  666. * f_fldset    This routine is used to set an objects flags based on 
  667. *        the outcome of a 'and' operation.  The word is set to
  668. *        the 'truestate' if the operation is true else set to
  669. *        'falsestate'
  670. *    C binding: inf_fldset(tree,obj,tstfld,tstbit,truestate,falsestate);
  671. *
  672. * --
  673. _inf_fldset:
  674.     move.l    #OB_STATE,a0    ; a0 = offset to ob_state
  675.     bsr    get_addr
  676. ;
  677.     clr    d0
  678.     move.w    10(sp),d0    ; d0 = tstfld
  679.     and.w    12(sp),d0    ; d0 = tstfld & tstbit
  680.     beq    false
  681.     move.w    14(sp),(a0)    ; set the word to the 'truestate'
  682.     bra    inf1
  683. false:
  684.     move.w    16(sp),(a0)    ; set the word to the 'falsestate'
  685. inf1:
  686.     rts
  687.  
  688.  
  689. * --
  690. *
  691. * inf_gindex    for each object from baseobj for N objects return the object
  692. *        that is selected or -1 if no objects are selected.
  693. *        C binding:    inf_gindex(tree,baseobj,n);
  694. *                    word    baseobj,n;
  695. *                    long    tree;
  696. * --
  697. _inf_gind:
  698.     move.l    #OB_STATE+1,a0    ; a0 = offset to byte to test
  699.     bsr    get_addr
  700. ;
  701.     move.w    10(sp),d0    ; d0 = n
  702.     subq.w    #1,d0        ; adjust for dbra
  703.     move.w    d0,d1        ; d1 = copy of count
  704. nxtstat:
  705.     btst.b    #0,(a0)        ; if( OB_STATE & SELECTED)
  706.     beq    gind1
  707.     sub.w    d1,d0        ; get object number
  708.     bra    gindout
  709. gind1:
  710.     adda.l    #OB_SIZE,a0    ; next object state to test
  711.     dbra    d1,nxtstat
  712.     move.w    d1,d0        ; d0 = -1
  713. gindout:
  714.     rts
  715.  
  716. * --
  717. *
  718. * inf_what    Return     0 is cancel was selected
  719. *             1 if ok was selected
  720. *            -1 if nothing is selected
  721. *        If an object was selected then deselect it.
  722. *        C binding:    inf_what(tree,ok,cancel);
  723. *                    word    ok,cancel;
  724. *                    long    tree;
  725. * --
  726. _inf_what:
  727.     move.w    #2,-(sp)    ; sp = 2
  728.     move.w    10(sp),-(sp)    ; sp = ok
  729.     move.l    8(sp),-(sp)    ; sp = tree
  730.     ;jsr    _inf_gin    
  731.     ; find selected object
  732.     addq.l    #8,sp
  733. ;
  734.     cmp.w    #-1,d0        ; if (ret == -1)
  735.     beq    genrts
  736. ;
  737.     move.w    d0,d1        ; save return value
  738. ;
  739.     add.w    d0,8(sp)    ; 8(sp) = object# + ret
  740.     move.l    #OB_STATE,a0    ; a0 = offset to ob_state
  741.     bsr    get_addr
  742. ;
  743.     clr.w    (a0)        ; set ob_state to NORMAL
  744.     tst.w    d1
  745.     beq    rettrue
  746. *
  747. * general return true/false exit point
  748. *
  749. retfalse:
  750.     clr.w    d0
  751.     bra    genrts
  752. rettrue:
  753.     move.w    #1,d0        ; return 1 if ok is selected
  754. genrts:
  755.     rts
  756.  
  757.  
  758.  
  759. * --
  760. * merge_str
  761. *        C binding:    merge_str(dest,src,parms);
  762. *                    byte    *dest,src;
  763. *                    uword    parms[];
  764. * --
  765.  
  766. PARMS    =    7*4
  767.  
  768. _merge_st:
  769.     movem.l    d3-d6/a3-a5,-(sp)    ; save d3,d4,d5,d6,a3,a4,a5
  770.     movem.l    PARMS+4(sp),a3-a5    ; a3 -> dest, a4 -> src, a5 -> parms
  771.     clr.w    d3            ; d3 = parms[] index
  772. ;
  773. mernxt:
  774.     tst.b    (a4)        ; if (char = 0) get out
  775.     beq    merout
  776. ;
  777.     cmp.b    #'%',(a4)    ; if(char == '%')
  778.     beq    do_per
  779.     move.b    (a4)+,(a3)+    ; dest = src
  780.     bra    mernxt
  781. ;
  782. do_per:
  783.     tst.b    (a4)+        ; inc past '%'
  784.     move.b    (a4)+,d0
  785.     cmp.b    #PERCENT,d0    ; if (char != '%')
  786.     bne    ltest
  787.     move.b    d0,(a3)+    ; dest = '%'
  788.     bra    mernxt
  789. ltest:
  790.     cmp.b    #CAP_L,d0    ; if (char != 'L')
  791.     bne    wtest
  792.     move.w    d3,a0        ; a0 = num
  793.     add.l    a5,a0        ; a0 = &parms[] + num (index)
  794.     move.l    (a0),d4        ; d4 = lvalue
  795.     addq.w    #4,d3        ; inc num
  796.     bra    dovalue
  797. wtest:
  798.     cmp.b    #CAP_W,d0    ; if (char != 'W')
  799.     bne    stest
  800.     clr.l    d4        ; d4 = 0
  801.     move.w    d3,a0        ; a0 = num
  802.     add.l    a5,a0        ; a0 = &parms[] + num (index)
  803.     move.w    (a0),d4        ; d4 = lvalue
  804.     addq.w    #4,d3        ; inc num
  805.     bra    dovalue
  806. stest:
  807.     cmp.b    #CAP_S,d0    ; if (char != 'S')
  808.     bne    mernxt        ; else do next character
  809.     move.w    d3,a0        ; a0 = num
  810.     add.l    a5,a0        ; a0 = &parms[] + num (index)
  811.     move.l    (a0),a0        ; a0 = src pointer
  812.     addq.w    #4,d3        ; inc num
  813. s1:
  814.     tst.b    (a0)        ; If (character)
  815.     beq    mernxt        ; do next character
  816.     move.b    (a0)+,(a3)+    ; dest = src
  817.     bra    s1
  818. ;
  819. dovalue:
  820.     clr.l    d5        ; d5 is index
  821.     sub.l    #16,sp        ; get room on stack
  822. ;
  823. nxtdigit:
  824.     tst.l    d4        ; more digits (lvalue)
  825.     beq    nomore
  826.     move.l    #$a,-(sp)
  827.     move.l    d4,-(sp)
  828.         ;jsr    ldiv
  829.     move.l    d0,d6        ; x = d6 = lvalue / 10
  830.     move.l    d0,(sp)
  831.     ;jsr    lmul
  832.     addq.l #8,sp        ; d0 = (x * 10)
  833.     move.l    d4,d2
  834.     sub.l    d0,d2        ; d2 = lvalue - (x * 10)
  835.     add    #$30,d2        ; d2 = ascii value
  836.     move.b    d2,(sp,d5.w)    ; save character
  837.     add.w    #1,d5        ; inc index
  838.     move.l    d6,d4        ; lvalue = x
  839.     bra    nxtdigit
  840. nomore:
  841.     subq.w    #1,d5        ; adjust for dbra
  842.     bge    ascdig
  843.     move.b    #'0',(a3)+    ; move digit
  844.     bra    stclean
  845. ascdig:
  846.     move.b    (sp,d5.w),(a3)+    ; copy digit
  847.     dbra    d5,ascdig
  848. stclean:
  849.     add.l    #16,sp        ; clean up stack
  850.     bra    mernxt
  851. merout:
  852.     clr.b    (a3)        ; null terminate string
  853.     movem.l    (sp)+,d3-d6/a3-a5 ; restore d3,d4,d5,d6,a3,a4,a5
  854.     rts
  855.  
  856. * --
  857. *
  858. * wildcmp
  859. *        C binding:    wildcmp(pwild,ptest);
  860. *                    byte    *pwild,*ptest;
  861. * --
  862.  
  863. _wildcmp:
  864.     movem.l 4(sp),a0-a1    ; a0-> pwild, a1 -> ptest
  865. wildnxt:
  866.     tst.b    (a0)        ; no pwild source
  867.     beq    wld5
  868.     tst.b    (a1)        ; no ptest source
  869.     beq    wld5
  870.     cmp.b    #QUEST,(a0)    ; if ( *pwild != '?' )
  871.     bne    wld1
  872.     add.l    #1,a0        ; pwild += 1
  873.     cmp.b    #DOT,(a1)    ; if ( *ptest != '.')
  874.     beq    wildnxt
  875. inctest:
  876.     add.l    #1,a1        ; ptest += 1
  877.     bra    wildnxt
  878. wld1:
  879.     cmp.b    #STAR,(a0)    ; if (*pwild != '*')
  880.     bne    wld2
  881.     cmp.b    #DOT,(a1)    ; if (*ptest != '.')
  882.     bne    inctest
  883.     add.l    #1,a0        ; pwild += 1
  884.     bra    wildnxt
  885. wld2:
  886.     move.b    (a0),d0
  887.     cmp.b    (a1),d0        ; if (*pwild == *ptest)
  888.     bne    wldfalse
  889.     add.l    #1,a0        ; pwild += 1
  890.     bra    inctest
  891. wld6:
  892.     add.l    #1,a0        ; pwild++
  893. wld5:
  894.     cmp.b    #STAR,(a0)    ; if (*pwild == '*')
  895.     beq    wld6
  896.     cmp.b    #QUEST,(a0)    ; || (*pwild == '?')
  897.     beq    wld6
  898.     cmp.b    #DOT,(a0)    ; || (*pwild == '.')
  899.     beq    wld6
  900. *
  901.     tst.b    (a0)        ; if (*pwild == char)
  902.     bne    wldfalse
  903.     tst.b    (a1)        ; || (*ptest == char)
  904.     bne    wldfalse
  905.     move.w    #1,d0        ; return true
  906.     bra    wldout
  907. wldfalse:
  908.     clr.w    d0        ; else return false
  909. wldout:
  910.     rts
  911.  
  912.  
  913. * --
  914. *
  915. * get_addr    Calculate the objects address given:
  916. *            a0 = object offset
  917. *            12(sp) = object
  918. *            8(sp)  = tree
  919. *--
  920. get_addr:
  921.     move.w    12(sp),d0    ; d0 = object
  922.     muls    #OB_SIZE,d0    ; d0 = object ; ob_size
  923.     add.l    8(sp),a0    ; a0 = tree + offset
  924.     add.l    d0,a0        ; a0 -> desired word or long
  925.     rts
  926.  
  927.  
  928. *    OPTIMIZE.C    1/25/84 - 01/27/85    Lee Jay Lorenzen    */
  929. *    reg op 68k    2/10/85 - 04/03/85    LKW            */
  930. *    remove mid,cmps 06/10/85        Mike Schmal        */
  931. *        bit_num    06/10/85        Mike Schmal        */
  932. *    Fix the bfill    4/3/86            Derek Mui        */
  933. *
  934. *
  935. *    -------------------------------------------------------------
  936. *    GEM Application Environment Services          Version 1.1
  937. *    Serial No.  XXXX-0000-654321          All Rights Reserved
  938. *    Copyright (C) 1985            Digital Research Inc.
  939. *    -------------------------------------------------------------
  940. **/
  941. *
  942. *#include <portab.h>
  943. *#include <machine.h>
  944. *#include <taddr.h>
  945. *#include <obdefs.h>
  946. *
  947. *
  948. *EXTERN WORD    gl_wchar;
  949. *EXTERN WORD    gl_hchar;
  950. *
  951. *
  952. *r_get(pxywh, px, py, pw, ph)
  953. *    REG WORD    *pxywh;
  954. *    WORD        *px, *py, *pw, *ph;
  955. *{
  956. *    *px = pxywh[0];
  957. *    *py = pxywh[1];
  958. *    *pw = pxywh[2];
  959. *    *ph = pxywh[3];
  960. *}
  961. *
  962. *
  963. *
  964. *r_set(pxywh, x, y, w, h)
  965. *    REG WORD    *pxywh;
  966. *    WORD        x, y, w, h;
  967. *{
  968. *    pxywh[0] = x;
  969. *    pxywh[1] = y;
  970. *    pxywh[2] = w;
  971. *    pxywh[3] = h;
  972. *}
  973. *
  974. *
  975. *rc_constrain(pc, pt)
  976. *    REG GRECT    *pc;
  977. *    REG GRECT    *pt;
  978. *{
  979. *      if (pt->g_x < pc->g_x)
  980. *        pt->g_x = pc->g_x;
  981. *      if (pt->g_y < pc->g_y)
  982. *        pt->g_y = pc->g_y;
  983. *      if ((pt->g_x + pt->g_w) > (pc->g_x + pc->g_w))
  984. *        pt->g_x = (pc->g_x + pc->g_w) - pt->g_w;
  985. *      if ((pt->g_y + pt->g_h) > (pc->g_y + pc->g_h))
  986. *        pt->g_y = (pc->g_y + pc->g_h) - pt->g_h;
  987. *}
  988. *
  989. *
  990. *rc_copy(psxywh, pdxywh)
  991. *    REG WORD    *psxywh;
  992. *    REG WORD    *pdxywh;
  993. *{
  994. *    *pdxywh++ = *psxywh++;
  995. *    *pdxywh++ = *psxywh++;
  996. *    *pdxywh++ = *psxywh++;
  997. *    *pdxywh++ = *psxywh++;
  998. *}
  999. *
  1000. *
  1001. *    VOID
  1002. *rc_union(p1, p2)
  1003. *    REG GRECT    *p1, *p2;
  1004. *{
  1005. *    REG WORD    tx, ty, tw, th;
  1006. *
  1007. *    tw = max(p1->g_x + p1->g_w, p2->g_x + p2->g_w);
  1008. *    th = max(p1->g_y + p1->g_h, p2->g_y + p2->g_h);
  1009. *    tx = min(p1->g_x, p2->g_x);
  1010. *    ty = min(p1->g_y, p2->g_y);
  1011. *    p2->g_x = tx;
  1012. *    p2->g_y = ty;
  1013. *    p2->g_w = tw - tx;
  1014. *    p2->g_h = th - ty;
  1015. *}
  1016. *
  1017. *
  1018. *    WORD
  1019. *rc_intersect(p1, p2)
  1020. *    REG GRECT    *p1, *p2;
  1021. *{
  1022. *    REG WORD    tx, ty, tw, th;
  1023. *
  1024. *    tw = min(p2->g_x + p2->g_w, p1->g_x + p1->g_w);
  1025. *    th = min(p2->g_y + p2->g_h, p1->g_y + p1->g_h);
  1026. *    tx = max(p2->g_x, p1->g_x);
  1027. *    ty = max(p2->g_y, p1->g_y);
  1028. *    p2->g_x = tx;
  1029. *    p2->g_y = ty;
  1030. *    p2->g_w = tw - tx;
  1031. *    p2->g_h = th - ty;
  1032. *    return( (tw > tx) && (th > ty) );
  1033. *}
  1034. *
  1035. *
  1036. *    UWORD
  1037. *inside(x, y, pt)
  1038. *    REG WORD    x, y;
  1039. *    REG GRECT    *pt;
  1040. *{
  1041. *    if ( (x >= pt->g_x) && (y >= pt->g_y) &&
  1042. *         (x < pt->g_x + pt->g_w) && (y < pt->g_y + pt->g_h) )
  1043. *      return(TRUE);
  1044. *    else
  1045. *      return(FALSE);
  1046. *} /* inside */
  1047. *
  1048. *
  1049. *    WORD
  1050. *rc_equal(p1, p2)
  1051. *    REG WORD    *p1, *p2;
  1052. *{
  1053. *    REG WORD    i;
  1054. *
  1055. *    for(i=0; i<4; i++)
  1056. *    {
  1057. *      if (*p1++ != *p2++)
  1058. *        return(FALSE);
  1059. *    }
  1060. *    return(TRUE);
  1061. *}
  1062. *
  1063. *
  1064. *    VOID
  1065. *movs(num, ps, pd)
  1066. *    REG WORD    num;
  1067. *    REG BYTE    *ps, *pd;
  1068. *{
  1069. *    do
  1070. *      *pd++ = *ps++;
  1071. *    while (--num);
  1072. *}
  1073. *
  1074. *
  1075. *    WORD
  1076. *min(a, b)
  1077. *    WORD        a, b;
  1078. *{
  1079. *    return( (a < b) ? a : b );
  1080. *}
  1081. *
  1082. *
  1083. *    WORD
  1084. *max(a, b)
  1085. *    WORD        a, b;
  1086. *{
  1087. *    return( (a > b) ? a : b );
  1088. *}
  1089. *
  1090. *
  1091. *
  1092. *    VOID
  1093. *bfill(num, bval, addr)
  1094. *    REG WORD    num;
  1095. *    REG BYTE    bval;
  1096. *    REG BYTE    *addr;
  1097. *{
  1098. *    while(num)
  1099. *    {
  1100. *      *addr++ = bval;
  1101. *      num --;
  1102. *    }
  1103. *}
  1104. *
  1105. *
  1106. *    BYTE
  1107. *toupper(ch)
  1108. *    REG BYTE    ch;
  1109. *{
  1110. *    if ( (ch >= 'a') &&
  1111. *         (ch <= 'z') )
  1112. *      return(ch - 32);
  1113. *    else
  1114. *      return(ch);
  1115. *}
  1116. *
  1117. *    BYTE
  1118. **scasb(p, b)
  1119. *    REG BYTE        *p;
  1120. *    REG BYTE        b;
  1121. *{
  1122. *    for(; *p && *p != b; p++);
  1123. *    return (p);
  1124. *}
  1125. *
  1126. *    WORD
  1127. *strlen(p1)
  1128. *    REG BYTE    *p1;
  1129. *{
  1130. *    REG WORD    len;
  1131. *
  1132. *    len = 0;
  1133. *    while( *p1++ )
  1134. *      len++;
  1135. *
  1136. *    return(len);
  1137. *}
  1138. *
  1139. *
  1140. *    WORD
  1141. *strcmp(p1, p2)
  1142. *    REG BYTE    *p1, *p2;
  1143. *{
  1144. *    while(*p1)
  1145. *    {
  1146. *      if (*p1++ != *p2++)
  1147. *        return(FALSE);
  1148. *    }
  1149. *    if (*p2)
  1150. *      return(FALSE);
  1151. *    return(TRUE);
  1152. *}
  1153. *
  1154. *
  1155. */*
  1156. **    Return <0 if s<t, 0 if s==t, >0 if s>t
  1157. **/
  1158. *
  1159. *    WORD
  1160. *strchk(s, t)
  1161. *    REG BYTE    s[], t[];
  1162. *{
  1163. *    REG WORD    i;
  1164. *
  1165. *    i = 0;
  1166. *    while( s[i] == t[i] )
  1167. *      if (s[i++] == NULL)
  1168. *        return(0);
  1169. *    return(s[i] - t[i]);
  1170. *}
  1171. *
  1172. *
  1173. *    BYTE
  1174. **strcpy(ps, pd)
  1175. *    REG BYTE    *ps, *pd;
  1176. *{
  1177. *    while(*pd++ = *ps++)
  1178. *      ;
  1179. *    return(pd);
  1180. *}
  1181. *
  1182. *
  1183. *    BYTE
  1184. **strscn(ps, pd, stop)
  1185. *    REG BYTE    *ps, *pd, stop;
  1186. *{
  1187. *    while ( (*ps) &&
  1188. *        (*ps != stop) )
  1189. *      *pd++ = *ps++;
  1190. *    return(pd);
  1191. *}
  1192. *
  1193. *
  1194. *    BYTE
  1195. **strcat(ps, pd)
  1196. *    REG BYTE    *ps, *pd;
  1197. *{
  1198. *    while(*pd)
  1199. *      pd++;
  1200. *    while(*pd++ = *ps++)
  1201. *      ;
  1202. *    return(pd);
  1203. *}
  1204. *
  1205. *
  1206. */*
  1207. **    Strip out period and turn into raw data.
  1208. **/
  1209. *    VOID
  1210. *fmt_str(instr, outstr)
  1211. *    REG BYTE    *instr, *outstr;
  1212. *{
  1213. *    REG WORD    count;
  1214. *    REG BYTE    *pstr;
  1215. *
  1216. *    pstr = instr;
  1217. *    while( (*pstr) && (*pstr != '.') )
  1218. *      *outstr++ = *pstr++;
  1219. *    if (*pstr)
  1220. *    {
  1221. *      count = 8 - (pstr - instr);
  1222. *      while ( count-- )
  1223. *        *outstr++ = ' ';
  1224. *      pstr++;
  1225. *      while (*pstr)
  1226. *        *outstr++ = *pstr++;
  1227. *    }
  1228. *    *outstr = NULL;
  1229. *}
  1230. *
  1231. *
  1232. */*
  1233. **    Insert in period and make into true data.
  1234. **/
  1235. *    VOID
  1236. *unfmt_str(instr, outstr)
  1237. *    REG BYTE    *instr, *outstr;
  1238. *{
  1239. *    REG BYTE    *pstr, temp;
  1240. *
  1241. *    pstr = instr;
  1242. *    while( (*pstr) && ((pstr - instr) < 8) )
  1243. *    {
  1244. *      temp = *pstr++;
  1245. *      if (temp != ' ')
  1246. *        *outstr++ = temp;
  1247. *    }
  1248. *    if (*pstr)
  1249. *    {
  1250. *      *outstr++ = '.';
  1251. *      while (*pstr)
  1252. *        *outstr++ = *pstr++;
  1253. *    }
  1254. *    *outstr = NULL;
  1255. *}
  1256. *
  1257. *
  1258. *    VOID
  1259. *fs_sset(tree, obj, pstr, ptext, ptxtlen)
  1260. *    LONG        tree;
  1261. *    WORD        obj;
  1262. *    LONG        pstr;
  1263. *    REG LONG    *ptext;
  1264. *    WORD        *ptxtlen;
  1265. *{
  1266. *    REG LONG    spec;
  1267. *
  1268. *    *ptext = LLGET( spec = LLGET(OB_SPEC(obj)) );
  1269. *    LSTCPY(*ptext, pstr);
  1270. *    *ptxtlen = LWGET( spec + 24 );
  1271. *}
  1272. *
  1273. *
  1274. *    VOID
  1275. *inf_sset(tree, obj, pstr)
  1276. *    LONG        tree;
  1277. *    WORD        obj;
  1278. *    BYTE        *pstr;
  1279. *{
  1280. *    LONG        text;
  1281. *    WORD        txtlen;
  1282. *
  1283. *    fs_sset(tree, obj, ADDR(pstr), &text, &txtlen);
  1284. *}
  1285. *
  1286. *
  1287. *    VOID
  1288. *fs_sget(tree, obj, pstr)
  1289. *    LONG        tree;
  1290. *    WORD        obj;
  1291. *    LONG        pstr;
  1292. *{
  1293. *    LONG        ptext;
  1294. *
  1295. *    ptext = LLGET( LLGET(OB_SPEC(obj)) );
  1296. *    LSTCPY(pstr, ptext);
  1297. *}
  1298. *
  1299. *
  1300. *    VOID
  1301. *inf_sget(tree, obj, pstr)
  1302. *    LONG        tree;
  1303. *    WORD        obj;
  1304. *    BYTE        *pstr;
  1305. *{
  1306. *    fs_sget(tree, obj, ADDR(pstr));
  1307. *}
  1308. *
  1309. *
  1310. *    VOID
  1311. *inf_fldset(tree, obj, testfld, testbit, truestate, falsestate)
  1312. *    LONG        tree;
  1313. *    WORD        obj;
  1314. *    UWORD        testfld, testbit;
  1315. *    UWORD        truestate, falsestate;
  1316. *{
  1317. *    LWSET(OB_STATE(obj), (testfld & testbit) ? truestate : falsestate);
  1318. *}
  1319. *
  1320. *
  1321. *    WORD
  1322. *inf_gindex(tree, baseobj, numobj)
  1323. *    LONG        tree;
  1324. *    WORD        baseobj;
  1325. *    WORD        numobj;
  1326. *{
  1327. *    WORD        retobj;
  1328. *
  1329. *    for (retobj=0; retobj < numobj; retobj++)
  1330. *    {
  1331. *      if (LWGET(OB_STATE(baseobj+retobj)) & SELECTED)
  1332. *        return(retobj);
  1333. *    }
  1334. *    return(-1);
  1335. *}
  1336. *
  1337. *
  1338. */*
  1339. **    Return 0 if cancel was selected, 1 if okay was selected, -1 if
  1340. **    nothing was selected.
  1341. **/
  1342. *
  1343. *    WORD
  1344. *inf_what(tree, ok, cncl)
  1345. *    REG LONG        tree;
  1346. *    REG WORD        ok, cncl;
  1347. *{
  1348. *    REG WORD        field;
  1349. *
  1350. *    field = inf_gindex(tree, ok, 2);
  1351. *
  1352. *    if (field != -1)
  1353. *    {
  1354. *      LWSET(OB_STATE(ok + field), NORMAL);
  1355. *      field = (field == 0);
  1356. *    }
  1357. *    return(field);
  1358. *}
  1359. *
  1360. *
  1361. *    WORD
  1362. *merge_str(pdst, ptmp, parms)
  1363. *    REG BYTE    *pdst;
  1364. *    REG BYTE    *ptmp;
  1365. *    UWORD        parms[];    
  1366. *{
  1367. *    REG WORD        num;
  1368. *    WORD        do_value;
  1369. *    BYTE        lholder[12];
  1370. *    REG BYTE        *pnum;
  1371. *    BYTE        *psrc;
  1372. *    REG LONG        lvalue, divten;
  1373. *    WORD        digit;
  1374. *
  1375. *    num = 0;
  1376. *    while(*ptmp)
  1377. *    {
  1378. *      if (*ptmp != '%')
  1379. *        *pdst++ = *ptmp++;
  1380. *      else
  1381. *      {
  1382. *        ptmp++;
  1383. *        do_value = FALSE;
  1384. *        switch(*ptmp++)
  1385. *        {
  1386. *          case '%':
  1387. *        *pdst++ = '%';
  1388. *        break;
  1389. *          case 'L':
  1390. *        lvalue = *((LONG *) &parms[num]);
  1391. *        num += 2;
  1392. *        do_value = TRUE;
  1393. *        break;
  1394. *          case 'W':
  1395. *        lvalue = parms[num];
  1396. *#if MC68K
  1397. *        num += 2;
  1398. *#endif
  1399. *#if I8086
  1400. *        num++;
  1401. *#endif
  1402. *        do_value = TRUE;
  1403. *        break;
  1404. *          case 'S':
  1405. *        psrc = (BYTE *) parms[num]; 
  1406. *#if MC68K
  1407. *        num += 2;
  1408. *#endif
  1409. *#if I8086
  1410. *        num++;
  1411. *#endif
  1412. *        while(*psrc)
  1413. *          *pdst++ = *psrc++;
  1414. *        break;
  1415. *        }
  1416. *        if (do_value)
  1417. *        {
  1418. *          pnum = &lholder[0];
  1419. *          while(lvalue)
  1420. *          {
  1421. *        divten = lvalue / 10;
  1422. *        digit = (WORD) lvalue - (divten * 10);
  1423. *        *pnum++ = '0' + digit;
  1424. *        lvalue = divten;
  1425. *          }
  1426. *          if (pnum == &lholder[0])
  1427. *        *pdst++ = '0';
  1428. *          else
  1429. *          {
  1430. *        while(pnum != &lholder[0])
  1431. *          *pdst++ = *--pnum;
  1432. *          }
  1433. *        }
  1434. *      }
  1435. *    }
  1436. *    *pdst = NULL;
  1437. *}
  1438. *
  1439. *
  1440. *    WORD
  1441. *wildcmp(pwild, ptest)
  1442. *    REG BYTE        *pwild;
  1443. *    REG BYTE        *ptest;
  1444. *{
  1445. *    while( (*ptest) && 
  1446. *           (*pwild) )
  1447. *    {
  1448. *      if (*pwild == '?')
  1449. *      {
  1450. *         pwild++;
  1451. *         if (*ptest != '.')
  1452. *           ptest++;
  1453. *      }
  1454. *      else
  1455. *      {
  1456. *        if (*pwild == '*')
  1457. *        {
  1458. *          if (*ptest != '.')
  1459. *        ptest++;
  1460. *          else        
  1461. *        pwild++;
  1462. *        }
  1463. *        else
  1464. *        {
  1465. *          if (*ptest == *pwild)
  1466. *          {
  1467. *            pwild++;
  1468. *            ptest++;
  1469. *          }
  1470. *          else
  1471. *            return(FALSE);
  1472. *        }
  1473. *      }
  1474. *    }
  1475. *                        /* eat up remaining     */
  1476. *                        /*   wildcard chars    */
  1477. *    while( (*pwild == '*') ||
  1478. *           (*pwild == '?') ||
  1479. *           (*pwild == '.') )
  1480. *      pwild++;
  1481. *                        /* if any part of wild-    */
  1482. *                        /*   card or test is    */
  1483. *                        /*   left then no match    */
  1484. *    if ( (*pwild) ||
  1485. *         (*ptest) )
  1486. *      return(FALSE);
  1487. *    else
  1488. *      return(TRUE);
  1489. *}
  1490.